{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "Dueling DQN 核心思想是把 $Q$ 函数分解成状态价值函数 $V$ 和优势函数 $A$，这样可以更好地估计状态的价值和每个动作的优势，如下：\n",
    "\n",
    "$$\n",
    "Q(S, A, w, \\alpha, \\beta)=V(S, w, \\alpha)+\\left(A(S, A, w, \\beta)-\\frac{1}{\\mathcal{A}} \\sum_{a^{\\prime} \\in \\mathcal{A}} A\\left(S, a^{\\prime}, w, \\beta\\right)\\right)\n",
    "$$\n",
    "\n",
    "这种分解有助于在某些状态下，更好地区分动作的优劣，尤其是在某些状态下，不同动作的价值差异不大的情况下。这种结构能够更高效地学习 $Q$ 值，从而提高策略的表现。\n",
    "\n",
    "注意：\n",
    "* 结构上，Dueling DQN 和 Actor-Critic 有一定的相似性，但是 Actor-Critic 是基于策略梯度的方法，而 Dueling DQN 是基于值函数的方法, 感兴趣的读者可自行研究区别。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:40:51.875323300Z",
     "start_time": "2024-07-31T09:40:50.520076100Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, n_states, n_actions,hidden_dim=128):\n",
    "        super(Model, self).__init__()\n",
    "        \n",
    "        # hidden layer\n",
    "        self.hidden_layer = nn.Sequential(\n",
    "            nn.Linear(n_states, hidden_dim),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        #  advantage\n",
    "        self.advantage_layer = nn.Sequential(\n",
    "            nn.Linear(hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, n_actions)\n",
    "        )\n",
    "        \n",
    "        # value\n",
    "        self.value_layer = nn.Sequential(\n",
    "            nn.Linear(hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, 1)\n",
    "        )\n",
    "        \n",
    "    def forward(self, state):\n",
    "        x = self.hidden_layer(state)\n",
    "        advantage = self.advantage_layer(x)\n",
    "        value     = self.value_layer(x)\n",
    "        return value + advantage - advantage.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "同 DQN，Dueling DQN 也使用经验回放来训练模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:40:53.985457100Z",
     "start_time": "2024-07-31T09:40:53.959303800Z"
    }
   },
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        ''' 清空经验回放\n",
    "        '''\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "除了 Model 不同外，其他部分和 DQN 一样。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:40:56.271853Z",
     "start_time": "2024-07-31T09:40:56.257853800Z"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "class Policy:\n",
    "    def __init__(self,cfg):\n",
    "        self.target_update = cfg.target_update\n",
    "        self.action_dim = cfg.action_dim  \n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.gamma = cfg.gamma # 奖励的折扣因子\n",
    "        # e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end =cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.memory = ReplayBuffer(cfg.memory_capacity)\n",
    "        # 当前网络和目标网络\n",
    "        self.policy_net = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        self.target_net = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        # 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "            target_param.data.copy_(param.data)\n",
    "        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器\n",
    "        self.update_cnt = 0 # 用于延迟更新目标网络的计数\n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon指数衰减\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            with torch.no_grad():\n",
    "                state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "                q_values = self.policy_net(state)\n",
    "                action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim)\n",
    "        return action\n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        q_values = self.policy_net(state)\n",
    "        action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        return action\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 从经验回放中随机采样一个批量的样本\n",
    "        states, actions, rewards, next_states, dones = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        # 将数据转换为tensor\n",
    "        states = torch.tensor(np.array(states), device=self.device, dtype=torch.float) # [batch_size, state_dim]\n",
    "        actions = torch.tensor(actions, device=self.device).unsqueeze(1)  #  [batch_size, 1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1)   # [batch_size, 1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [batch_size, state_dim]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1)  # [batch_size,1]\n",
    "        # 计算当前状态(s_t,a)对应的Q值\n",
    "        q_values = self.policy_net(states).gather(dim=1, index=actions) \n",
    "        # 计算下一时刻的状态(s_t_,a)对应的Q值，注意需要detach()，因为不需要计算梯度\n",
    "        next_q_values_max = self.target_net(next_states).max(1)[0].detach().unsqueeze(1)\n",
    "        # 计算期望的Q值，对于终止状态，此时dones[0]=1, 对应的expected_q_value等于reward\n",
    "        expected_q_values = rewards + self.gamma * next_q_values_max * (1-dones) # [batch_size, 1]\n",
    "         # 计算均方根损失\n",
    "        loss = nn.MSELoss()(q_values, expected_q_values) \n",
    "        # 优化更新模型\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # clip防止梯度爆炸\n",
    "        for param in self.policy_net.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "        self.update_cnt += 1\n",
    "        # 每隔一定步数更新目标网络的参数\n",
    "        if self.update_cnt % self.target_update == 0:\n",
    "            for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "                target_param.data.copy_(param.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:40:59.960420200Z",
     "start_time": "2024-07-31T09:40:59.857108500Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "def train(cfg):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = gym.make(cfg.env_id)\n",
    "    setattr(cfg, \"action_space\", env.action_space)\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "    setattr(cfg, \"action_dim\", env.action_space.n)\n",
    "    policy = Policy(cfg)\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    frames = []\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            policy.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{policy.epsilon:.3f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T10:10:06.222968700Z",
     "start_time": "2024-07-31T10:10:06.213970200Z"
    }
   },
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'DuelingDQN' # 算法名称\n",
    "        self.env_id = 'Acrobot-v1' # 环境id\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.train_eps = 200 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.max_steps = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        self.gamma = 0.95 # 折扣因子\n",
    "        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon\n",
    "        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon\n",
    "        self.epsilon_decay = 2000 # e-greedy策略中epsilon的衰减率\n",
    "        self.memory_capacity = 100000 # 经验回放池的容量\n",
    "        self.hidden_dim = 128 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 64 # 批次大小\n",
    "        self.target_update = 100 # 目标网络的更新频率\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T10:13:39.275865600Z",
     "start_time": "2024-07-31T10:10:08.506453500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t     DuelingDQN     \t   <class 'str'>    \n",
      "       env_id       \t     Acrobot-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "     train_eps      \t        200         \t   <class 'int'>    \n",
      "      test_eps      \t         20         \t   <class 'int'>    \n",
      "     max_steps      \t        200         \t   <class 'int'>    \n",
      "       gamma        \t        0.95        \t  <class 'float'>   \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t        2000        \t   <class 'int'>    \n",
      "  memory_capacity   \t       100000       \t   <class 'int'>    \n",
      "     hidden_dim     \t        128         \t   <class 'int'>    \n",
      "     batch_size     \t         64         \t   <class 'int'>    \n",
      "   target_update    \t        100         \t   <class 'int'>    \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/200，奖励：-200.00，Epislon：0.356\n",
      "回合：20/200，奖励：-200.00，Epislon：0.137\n",
      "回合：30/200，奖励：-200.00，Epislon：0.057\n",
      "回合：40/200，奖励：-200.00，Epislon：0.027\n",
      "回合：50/200，奖励：-200.00，Epislon：0.016\n",
      "回合：60/200，奖励：-200.00，Epislon：0.013\n",
      "回合：70/200，奖励：-97.00，Epislon：0.011\n",
      "回合：80/200，奖励：-141.00，Epislon：0.011\n",
      "回合：90/200，奖励：-133.00，Epislon：0.010\n",
      "回合：100/200，奖励：-200.00，Epislon：0.010\n",
      "回合：110/200，奖励：-100.00，Epislon：0.010\n",
      "回合：120/200，奖励：-125.00，Epislon：0.010\n",
      "回合：130/200，奖励：-146.00，Epislon：0.010\n",
      "回合：140/200，奖励：-125.00，Epislon：0.010\n",
      "回合：150/200，奖励：-149.00，Epislon：0.010\n",
      "回合：160/200，奖励：-113.00，Epislon：0.010\n",
      "回合：170/200，奖励：-118.00，Epislon：0.010\n",
      "回合：180/200，奖励：-87.00，Epislon：0.010\n",
      "回合：190/200，奖励：-200.00，Epislon：0.010\n",
      "回合：200/200，奖励：-114.00，Epislon：0.010\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg)\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "joyrl-book",
   "language": "python",
   "display_name": "Python (joyrl-book)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "f5a9629e9f3b9957bf68a43815f911e93447d47b3d065b6a8a04975e44c504d9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
